//! REST API测试

use crate::client::BinanceClientBuilder;
use crate::rest::RestClient;
use crate::{Environment, ProductType};
use std::collections::HashMap;

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_rest_client_creation() {
        let config = crate::config::BinanceConfig::new(
            "test_api_key".to_string(),
            "test_secret_key".to_string(),
            ProductType::Spot,
        );

        let rest_client = RestClient::new(std::sync::Arc::new(config));
        assert!(rest_client.is_ok());
    }

    #[tokio::test]
    async fn test_rest_client_get() {
        let client = BinanceClientBuilder::new(
            "test_api_key".to_string(),
            "test_secret_key".to_string(),
            ProductType::Spot,
        )
        .environment(Environment::Demo)
        .build()
        .unwrap();

        // 测试获取服务器时间（不需要签名）
        let result = client.rest().get("/time", false).await;
        // 这里可能会失败，因为需要真实的网络连接
        // 但至少验证了方法调用不会panic
        assert!(result.is_ok() || result.is_err());
    }

    #[tokio::test]
    async fn test_rest_client_post() {
        let client = BinanceClientBuilder::new(
            "test_api_key".to_string(),
            "test_secret_key".to_string(),
            ProductType::Spot,
        )
        .environment(Environment::Demo)
        .build()
        .unwrap();

        let mut params = HashMap::new();
        params.insert("symbol".to_string(), "BTCUSDT".to_string());
        params.insert("side".to_string(), "BUY".to_string());
        params.insert("type".to_string(), "LIMIT".to_string());
        params.insert("quantity".to_string(), "0.001".to_string());
        params.insert("price".to_string(), "50000.00".to_string());

        // 测试POST请求（需要签名）
        let result = client.rest().post("/order", &params, true).await;
        // 这里可能会失败，因为需要真实的API密钥
        // 但至少验证了方法调用不会panic
        assert!(result.is_ok() || result.is_err());
    }

    #[tokio::test]
    async fn test_rest_client_put() {
        let client = BinanceClientBuilder::new(
            "test_api_key".to_string(),
            "test_secret_key".to_string(),
            ProductType::Spot,
        )
        .environment(Environment::Demo)
        .build()
        .unwrap();

        // 测试PUT请求
        let result = client.rest().put("/userDataStream", true).await;
        // 这里可能会失败，因为需要真实的API密钥
        assert!(result.is_ok() || result.is_err());
    }

    #[tokio::test]
    async fn test_rest_client_delete() {
        let client = BinanceClientBuilder::new(
            "test_api_key".to_string(),
            "test_secret_key".to_string(),
            ProductType::Spot,
        )
        .environment(Environment::Demo)
        .build()
        .unwrap();

        // 测试DELETE请求
        let result = client.rest().delete("/userDataStream", true).await;
        // 这里可能会失败，因为需要真实的API密钥
        assert!(result.is_ok() || result.is_err());
    }

    #[tokio::test]
    async fn test_rest_client_with_proxy() {
        let client = BinanceClientBuilder::new(
            "test_api_key".to_string(),
            "test_secret_key".to_string(),
            ProductType::Spot,
        )
        .environment(Environment::Demo)
        .proxy(
            Some("http://127.0.0.1:8080".to_string()),
            Some("socks5://127.0.0.1:1080".to_string()),
        )
        .build()
        .unwrap();

        // 测试带代理的请求
        let result = client.rest().get("/time", false).await;
        // 这里可能会失败，因为代理服务器可能不存在
        assert!(result.is_ok() || result.is_err());
    }

    #[test]
    fn test_rest_client_config_access() {
        let client = BinanceClientBuilder::new(
            "test_api_key".to_string(),
            "test_secret_key".to_string(),
            ProductType::Spot,
        )
        .build()
        .unwrap();

        let config = client.rest().config();
        assert_eq!(config.api_key, "test_api_key");
        assert_eq!(config.secret_key, "test_secret_key");
        assert_eq!(config.product_type, ProductType::Spot);
    }

    #[tokio::test]
    async fn test_rest_client_error_handling() {
        let client = BinanceClientBuilder::new(
            "invalid_api_key".to_string(),
            "invalid_secret_key".to_string(),
            ProductType::Spot,
        )
        .environment(Environment::Demo)
        .build()
        .unwrap();

        // 测试错误处理
        let result = client.rest().get("/account", true).await;
        // 这里应该失败，因为API密钥无效
        assert!(result.is_err());
    }

    #[tokio::test]
    async fn test_rest_client_timeout() {
        let client = BinanceClientBuilder::new(
            "test_api_key".to_string(),
            "test_secret_key".to_string(),
            ProductType::Spot,
        )
        .environment(Environment::Demo)
        .timeout(1) // 设置很短的超时时间
        .build()
        .unwrap();

        // 测试超时处理
        let result = client.rest().get("/time", false).await;
        // 这里可能会超时
        assert!(result.is_ok() || result.is_err());
    }

    #[tokio::test]
    async fn test_rest_client_retry() {
        let client = BinanceClientBuilder::new(
            "test_api_key".to_string(),
            "test_secret_key".to_string(),
            ProductType::Spot,
        )
        .environment(Environment::Demo)
        .retry_count(5)
        .build()
        .unwrap();

        // 测试重试机制
        let result = client.rest().get("/time", false).await;
        // 这里可能会重试
        assert!(result.is_ok() || result.is_err());
    }
}
